% ======================================================================
% 论文框架 (最终双栏排版)
% ======================================================================

% --- 修改开始：切换到双栏、Times字体的最终出版格式 ---
\documentclass[final,5p,times,twocolumn]{elsarticle}
% --- 修改结束 ---

% --- 基础宏包 ---
% 编码与字体支持
\usepackage[T1]{fontenc}
% 中文支持, 请务必使用 XeLaTeX 引擎进行编译
\usepackage{ctex} 
% 数学公式
\usepackage{amssymb}
\usepackage{amsmath}
% 图形支持
\usepackage{graphicx} 
% 页面布局
\usepackage{geometry}
% 超链接
\usepackage{hyperref} 
% 子图与子标题
\usepackage{subcaption} 
% 高质量表格
\usepackage{booktabs}
\usepackage{multirow}
% 支持表格中的多行单元格
\usepackage{makecell}
% 算法宏包
\usepackage{algorithm}
\usepackage{algpseudocode}
% verbatim代码块宏包
\usepackage{verbatim} 

\usepackage{listings} % 用于代码片段排版
\usepackage{xcolor}   % 用于定义颜色

% --- 修正：显式定义JavaScript和JSON语言支持 ---
\lstdefinelanguage{JavaScript}{
  keywords={typeof, new, true, false, catch, function, return, null, catch, switch, var, if, in, while, do, else, case, break},
  keywordstyle=\color{blue}\bfseries,
  ndkeywords={class, export, boolean, throw, implements, import, this},
  ndkeywordstyle=\color{darkgray}\bfseries,
  identifierstyle=\color{black},
  sensitive=false,
  comment=[l]{//},
  morecomment=[s]{/*}{*/},
  commentstyle=\color{purple}\ttfamily,
  stringstyle=\color{red}\ttfamily,
  morestring=[b]',
  morestring=[b]"
}

% --- 为JSON创建别名 ---
\lstalias{json}{JavaScript}

% --- listings 环境全局设置 ---
\lstset{
    language=JavaScript,
    basicstyle=\ttfamily\footnotesize, % 字体大小
    breaklines=true,                  % 自动换行
    postbreak=\mbox{\textcolor{red}{$\hookrightarrow$}\space}, % 换行符
    frame=tb,                         % 上下边框
    framerule=0.5pt,
    rulecolor=\color{gray!40},
    backgroundcolor=\color{gray!5},
    showstringspaces=false,
    tabsize=2,
    captionpos=b,                     % 标题位置
    aboveskip=1em,
    belowskip=1em
}


\journal{计算机学报} 

\begin{document}

% ======================================================================
% 扉页信息 (Frontmatter)
% ======================================================================
\begin{frontmatter}

\title{一种协同参数化数据流调用图与大语言模型的NPM恶意包检测方法}
\author{白鹤}
\affiliation{organization={内蒙古农业大学计算机与信息工程学院},%
            addressline={详细地址}, 
            city={呼和浩特},
            postcode={010018}, 
            country={中国}}

\begin{abstract}
\noindent
Node Package Manager (NPM) 作为全球最大的软件注册中心，其数百万的开源包在全球开发者中被广泛共享，但同时也日益成为软件供应链攻击者滥用以传播恶意软件的关键渠道。现有检测方法在面对不断演变的攻击时，往往受困于高误报率或高漏报率。为应对此挑战，本文提出一种协同参数化数据流调用图（PDCG）与大语言模型（LLM）的NPM恶意包检测方法。该方法通过深度融合程序的结构与语义信息来提升检测精度。我们的核心贡献包括：(1) 设计了一种新颖的程序图表示——参数化数据流调用图 (PDCG)，它能精确捕捉跨模块的行为关联与关键数据流；(2) 提出了一种基于大语言模型 (LLM) 的知识工程范式，以生成式方法自动提炼并泛化出一个可解释的恶意行为规则库，取代了对专家手动定义规则的依赖。在一个包含16,039个真实NPM包的大规模数据集上进行评估，我们的方法取得了98.1\%的F1分数，其性能优于现有基线方法。进一步的实验证明了我们方法的泛化能力以及语义与结构特征间的协同效应。本研究为深度审计NPM生态安全提供了一个有效且可扩展的解决方案。
\end{abstract}



\begin{keyword}
软件供应链安全 \sep 恶意检测 \sep 程序分析 \sep 参数化数据流调用图 \sep 大语言模型 \sep NPM
\end{keyword}


\end{frontmatter}


% 1. 引言 (Introduction)
% ======================================================================
\section{引言}
\label{sec:introduction}


\subsection{背景与动机}
随着开源软件的蓬勃发展，现代软件开发模式已深度依赖于第三方组件。据Sonatype报告，开源组件已占据现代软件应用的90\%，仅NPM生态在2024年的下载请求量预计就将超过4.4万亿次\cite{sonatype}。这种“站在巨人肩膀上”的开发模式在极大提高效率的同时，也引入了严峻的软件供应链安全挑战\cite{he2020software}。攻击者不再需要直接攻击最终用户，而是通过污染上游的开源组件，将恶意代码植入到成千上万的下游应用中，形成“牵一发而动全身”的破坏效果\cite{ji2022opensource}。近年来，SolarWinds后门事件\cite{martinez2021software}和Log4Shell漏洞\cite{apache2022log4j}等高危安全事件，更是将软件供应链攻击的巨大破坏力暴露无遗，凸显了对其进行深度防御的紧迫性。

NPM作为全球最大的软件注册中心，因其开放性和庞大的用户基数，已成为软件供应链攻击的重灾区\cite{sonatype}。Zimmermann等人\cite{zimmermann2019small}的研究揭示了NPM生态“小世界，高风险”的特性：安装一个普通的NPM包平均会引入对39个维护者和79个第三方包的隐式信任，形成一个巨大的攻击面。少数核心包或维护者账户的沦陷，就可能将恶意代码注入到生态系统的大多数包中。近年来，针对NPM的恶意攻击层出不穷，攻击手段也从简单的拼写混淆（Typosquatting）演变为复杂的、多阶段的潜伏与执行。因此，对NPM恶意软件包进行深度分析与精准检测，已成为保障软件供应链安全的关键环节。



\subsection{挑战与研究空白}
\label{sec:challenges}
尽管学术界和工业界对软件供应链安全日益重视，但现有的防御体系在面对NPM生态的复杂威胁时，仍存在若干关键的研究空白。

\textbf{首先，传统的程序分析模型难以适配恶意行为检测的新范式。} 现有静态分析大量借鉴了传统的漏洞挖掘方法，主要依赖抽象语法树（AST）或传统调用图（Call Graph）。然而，这些模型在恶意软件包检测这一新问题上显得“水土不服”：AST包含了过多的语法细节，导致分析效率低下且难以聚焦于核心行为；而传统调用图虽然关注函数调用，却往往忽略了决定行为性质的关键信息——\textbf{参数}。例如，一个`fetch`调用本身是中性的，但其参数若为恶意URL，则行为性质完全改变。这导致现有方法难以在一个合适的粒度上对恶意行为的结构进行深入分析。

\textbf{其次，恶意行为模式的定义与扩展面临瓶颈。} 在对现有恶意样本数据集的观察中，我们发现一个显著特点：大量恶意包采用了简单、重复、模式化的攻击手法。这为通过归纳学习来构建规则库提供了可能性。然而，传统依赖人类专家手动编写检测规则的方式，在面对层出不穷的攻击变种时，显得力不从心\cite{su2024learning}。如何系统性地、半自动化地从这些海量简单样本中归纳和提炼出高质量、高泛化能力的恶意行为知识，是当前研究的一个关键空白。

\textbf{更重要的是，我们观察到这两个挑战并非孤立存在，而是相互交织。} 一个先进的程序图表示若没有高质量的、可扩展的恶意行为知识来指导，其分析能力将大打折扣；反之，一个强大的知识库若应用于一个信息缺失或结构冗余的程序表示上，也无法发挥其最大效能。因此，一个能够将\textbf{适配恶意检测的程序图表示}与\textbf{自动化的知识提炼引擎}进行深度协同的分析框架，是解决当前困境的必然要求，但这在现有研究中尚未得到充分探索。

\subsection{本文方法与贡献}
\label{sec:contributions}
基于上述观察与挑战，本文的核心研究思路源于一个实践驱动的假设：\textbf{我们能否通过自动化学习大量简单、模式化的恶意样本，提炼出可泛化的行为知识，并以此为指导，在一个更适配恶意行为分析的程序表示上，实现对复杂、多变攻击的精准检测？}

为验证这一假设，我们提出了一种协同参数化数据流调用图（PDCG）与大语言模型（LLM）的NPM恶意包检测框架。该框架通过设计两个相互支撑的核心组件，并让它们协同工作，来系统性地应对前述挑战。本文的主要贡献如下：
\begin{itemize}
    \item \textbf{设计适配恶意检测的PDCG图表示：} 为解决传统程序模型不适配的问题（挑战一），我们设计了\textbf{参数化数据流调用图 (PDCG)}。它以“调用+参数”为核心，摒弃了无关的语法细节，专注于捕捉跨文件的行为关联与关键数据流，为后续的知识应用和结构分析提供了高效、精准的图表示。

    \item \textbf{构建LLM驱动的知识工程流程：} 为解决恶意行为模式定义与扩展的瓶颈（挑战二），我们创新性地将大语言模型（LLM）用作知识工程引擎。通过迭代式的“扩充-融合”流程，它能从简单的恶意样本中自动学习并生成结构化的、可解释的恶意行为规则，高效地解决了人工定义规则的难题。

    \item \textbf{实现并验证了“知识指导结构”的协同分析框架：} 我们将LLM生成的“语义”规则与PDCG的“结构”特征相结合，实现了对恶意行为的精准画像。实验证明，我们的方法在检测准确率和泛化能力上均优于现有检测器，成功验证了我们的核心假设以及协同分析的有效性。
\end{itemize}

% ... (后续部分不变) ...


\subsection{研究问题 (RQs)}
本研究旨在回答以下三个核心研究问题：
\begin{itemize}
    \item \textbf{RQ1 (有效性):} 与现有方法相比，我们提出的协同分析框架在恶意NPM包检测任务上的性能如何？
    \item \textbf{RQ2 (协同性):} 在我们的框架中，LLM生成的规则特征与PDCG的图结构特征各自贡献如何？它们之间是否存在协同效应？
    \item \textbf{RQ3 (知识有效性):} 我们提出的LLM知识工程范式，能否从简单的恶意样本中有效提炼出具备高覆盖率与泛化能力的恶意行为知识库？
\end{itemize}


\subsection{论文组织结构}
本文的其余部分组织如下：第二节回顾相关工作。第三节详细阐述我们提出的协同参数化数据流调用图与大语言模型的NPM恶意包检测方法。第四节介绍我们的实验设计。第五节展示并分析实验结果。第六节讨论我们工作的意义与局限。最后，第七节对全文进行总结。

\section{相关工作}
\label{sec:related_work}

本节旨在系统性地梳理恶意软件包的检测技术。我们将遵循技术演进的脉络，从传统的基于元数据和机器学习的方法，到更深入的基于行为序列与图的分析，再到新兴的无监督方法和前沿的大语言模型（LLM）应用，从而清晰地定位我们工作的创新之处。

\subsection{传统机器学习与元数据分析}
早期的恶意软件包检测主要依赖于静态提取的元数据和词法特征，并结合传统的机器学习模型进行分类。例如，Halder等人\cite{halder2024malicious}和Samaana等人\cite{samaana2025machine}的工作均利用了包的元数据、代码的文本特征等来训练分类器。我们选择的基线方法之一，Ladisa等人\cite{ladisa2023feasibility}提出的方法，也属于这一类别，它通过提取一组语言无关的特征（如安装脚本、混淆字符串、URL等）来训练模型，甚至实现了跨语言（NPM和PyPI）的检测。

这类方法的优势在于特征提取速度快、开销小。然而，它们的共同局限在于分析粒度较粗，难以深入理解代码的真实行为逻辑。攻击者可以通过伪造元数据或使用简单的代码混淆技术来轻易规避此类检测\cite{sun20241+}.

\subsection{基于行为序列与图的深度分析}
为了克服元数据分析的浅层局限，后续研究开始转向对代码行为的深度建模。一个主流方向是分析程序的行为序列，特别是API的调用序列。例如，我们选择的另一个基线方法Amalfi\cite{sejfia2022practical}，就是通过分析API调用序列等特征来识别恶意包。DONAPI\cite{huang2024donapi}则通过构建行为知识库来匹配API调用序列。Cerebro\cite{zhang2023malicious}更是将恶意行为抽象为序列，并利用预训练语言模型来理解其语义。

另一个更深入的方向是使用图来表征程序的复杂结构。研究者们认识到，恶意行为并非孤立的API调用，而是一个由控制流和数据依赖精心组织的“行为图”。例如，MalTracker\cite{yu2024maltracker}通过构建调用图和程序依赖图来提取细粒度的代码特征。SpiderScan\cite{huang2024spiderscan}则在图上对敏感API之间的控制流和数据依赖进行建模，并进行图匹配。这些基于图的方法能够更精确地刻画恶意行为的上下文和组织方式，但它们通常依赖于预定义的敏感API列表，且图的构建与分析过程相对复杂。我们的PDCG正是在这一背景下，旨在设计一种更轻量级、更聚焦于“调用+参数”核心行为的图表示。

\subsection{无监督与混合分析方法}
考虑到恶意样本的稀缺性和标签获取的困难，一些研究探索了无监督或半监督的方法。其核心假设是：恶意包在功能和结构上是“异常”的。MPHunter\cite{liang2023needle}就基于这一思想，认为恶意包在海量良性包中是“离群点”，它通过对安装脚本进行代码聚类来发现异常。ACME\cite{ohm2022towards}则利用代码复用的现象，通过对已知恶意包的AST进行聚类，来发现具有相同或相似恶意代码的“同源”攻击。

此外，为了结合不同分析维度的优势，混合分析成为一个重要趋势。OSCAR\cite{zheng2024towards}结合了动态模糊测试和静态API钩子监控。PypiGuard\cite{iqbal2025pypiguard}和Ea4MP\cite{sun20241+}则都探索了将静态元数据特征与动态/深度代码行为特征进行融合的策略，并证明了“1+1>2”的协同效应。这为我们结合“语义规则”和“图结构”的协同框架提供了有力的佐证。


\subsection{大语言模型（LLM）在检测中的应用}
近年来，大语言模型（LLM）的崛起为恶意代码分析带来了新的范式。现有研究主要分为两类：


\textbf{1. LLM作为“判别器”：} 大部分工作尝试将LLM直接用作一个黑盒分类器。例如，Zahan等人\cite{zahan2024leveraging}和Zeshan等人\cite{zeshan2024they}都评估了GPT系列和CodeLLaMA等模型直接检测恶意代码的能力。研究发现，尽管LLM表现出一定潜力，但其作为“判别器”时存在结果不稳定、可解释性差等问题\cite{zeshan2024they, xue2024poster}。

\textbf{2. LLM作为“特征/规则生成器”：} 另一类更具启发性的工作，是将LLM用于更“白盒”的任务。例如，MalPacDetector\cite{wang2025malpacdetector}利用LLM自动生成恶意行为的关键词和代码模式作为特征。RULELLM\cite{zhang2025automatically}则更进一步，利用LLM直接生成可部署的Yara和Semgrep规则。SpiderScan\cite{huang2024spiderscan}也利用LLM来辅助识别敏感API。


我们的工作属于第二类，并在此基础上提出了一个更完整的“知识工程”闭环。我们不仅利用LLM生成规则，更通过“扩充-融合”的迭代流程，引导LLM对生成的知识进行持续的精炼与泛化，旨在构建一个动态演进、可解释、可与下游图分析深度耦合的恶意行为知识库。

\section{协同参数化数据流调用图与大语言模型的NPM恶意包检测方法}
\label{sec:approach}

为验证我们在引言中提出的核心假设——即通过从简单样本中学习知识，并应用于一个适配的程序图表示上，以实现对复杂攻击的检测——我们设计了如图\ref{fig:framework}所示的协同检测框架。
\begin{figure*}[htbp!]
    \centering
    \includegraphics[width=\textwidth]{Pictures/framework_overview.png}
    \caption{我们提出的协同检测框架概览，该框架包含五个阶段：(1) 代码预处理与行为虚拟化；(2) PDCG构建；(3) 基于LLM的规则生成；(4) 协同分析与特征工程；(5) 恶意性判定。}
    \label{fig:framework}
\end{figure*}



该框架将复杂的恶意包检测任务分解为五个串联的阶段。其核心在于并行地构建结构化的程序图表示（PDCG）与语义化的行为知识（LLM规则库），并最终将两者结合进行协同分析。框架的五个阶段具体如下：
\begin{enumerate}
    \item \textbf{阶段一：代码预处理与行为虚拟化。} 解决恶意行为入口多样化的问题，特别是将`package.json`中隐藏的生命周期脚本，虚拟化为可供静态分析的JavaScript代码。
    \item \textbf{阶段二：参数化数据流调用图 (PDCG) 构建。} 将预处理后的代码集合转换为我们设计的PDCG，为后续分析提供一个信息丰富且结构简化的图表示。
    \item \textbf{阶段三：基于LLM的恶意行为规则生成。} 并行地，利用大语言模型对已知恶意样本进行分析，半自动化地生成一个高质量、可解释的恶意行为规则库。
    \item \textbf{阶段四：协同分析与特征工程。} 将LLM生成的规则应用于PDCG，提取规则匹配的“语义特征”和描述恶意行为上下文的“图结构特征”。
    \item \textbf{阶段五：基于机器学习的恶意性判定。} 将提取出的混合特征向量输入预训练的分类器中，对NPM包的恶意性进行最终判定。
\end{enumerate}

\subsection{阶段一：代码预处理与行为虚拟化}
\label{sec:preprocessing}

在NPM生态系统中，恶意行为的入口是多样化的。除了在被其他代码`require()`时执行恶意逻辑外，一个更为隐蔽的攻击面存在于`package.json`文件定义的生命周期脚本中。攻击者常利用`preinstall`、`install`或`postinstall`等脚本，在软件包被安装时自动执行恶意命令。传统的静态分析若仅扫描`.js`源代码，将完全忽略此类威胁。

为应对此挑战，我们首先对NPM包进行行为虚拟化处理，其核心目标是将分散在配置文件中的潜在执行入口，统一到可供静态分析的JavaScript上下文中。

例如，对于包含恶意脚本的`package.json`：
\begin{lstlisting}[language=json, caption={package.json中的恶意脚本}, label={lst:json_example}]
"preinstall": "curl http://malicious.link/Mal"
\end{lstlisting}

我们的预处理器会将其虚拟化为等价的JavaScript调用：
\begin{lstlisting}[caption={虚拟化后的JavaScript代码}, label={lst:js_virtual}]
spawn('curl', ['http://malicious.link/Mal']);
\end{lstlisting}

这种转换使得原本隐藏在配置文件中的恶意行为，能够被后续的静态分析引擎所捕获和分析。最终，我们将虚拟生成的入口文件与软件包中所有其他的`.js`文件共同组成一个统一的代码集合，确保了分析的完整性。




\subsection{阶段二：参数化数据流调用图 (PDCG) 构建}
\label{sec:pdcg_construction}

为在保留关键行为信息的同时有效降低分析复杂性，我们设计了一种新颖的程序图表示——参数化数据流调用图（Parameterized Data-Flow Call Graph, PDCG）。

\subsubsection{PDCG核心定义与设计思想}
从形式上，PDCG是一个有向图 $G=(V, E)$。其核心设计思想是\textbf{以“调用+参数”为骨架，构建一个面向行为的程序图}。如图\ref{fig:pdcg_concept}所示，PDCG通过对原始的抽象语法树（AST）进行一次有目的的“降维”和“修剪”，摒弃了大量与高层行为无关的语法细节（如具体的分支、循环结构），从而能够更专注于捕捉函数调用关系、关键参数的传递以及API的使用模式。

% --- 预留位置：高层次的概念图 ---
\begin{figure}[htbp!]
    \centering
    % \includegraphics[width=\columnwidth]{Pictures/pdcg_concept_diagram.png}
    \fbox{\parbox[c][8cm][c]{\columnwidth}{\centering \textit{[预留图片位置: pdcg\_concept\_diagram.png]} \\ \textit{从AST到PDCG的转换概念图}}}
    \caption{PDCG的设计思想：通过对AST进行修剪和简化，构建一个专注于核心行为的图表示。}
    \label{fig:pdcg_concept}
\end{figure}

\subsubsection{PDCG节点与边的设计}
PDCG的设计围绕JavaScript程序的核心语义元素，定义了六种节点类型和七种边类型，如表\ref{tab:pdcg_elements}所示。这些元素共同构成了描述程序行为的基础词汇表。

% --- 表格部分保持不变 ---
\begin{table}[htbp!]
    \centering
    \caption{PDCG的节点与边类型定义}
    \label{tab:pdcg_elements}
    \footnotesize
    \setlength{\tabcolsep}{4pt}
    \begin{tabular}{p{3.8cm}p{3.8cm}}
        \toprule
        \multicolumn{1}{c}{\textbf{节点类型}} & \multicolumn{1}{c}{\textbf{边类型}} \\
        \midrule
        \textbf{FILE:} 文件根节点 & \textbf{calls:} 调用关系 \\
        \textbf{CALL:} 函数调用 & \textbf{has\_arg:} 参数关系 \\
        \textbf{ARGUMENT:} 调用参数 & \textbf{chained:} 链式调用 \\
        \textbf{FUNC\_DEF:} 函数定义 & \textbf{callback:} 回调关系 \\
        \textbf{ANON\_FUNC:} 匿名函数 & \textbf{resolves:} 解析到定义 \\
        \textbf{PARAM:} 函数参数定义 & \textbf{defines:} 定义关系 \\
         & \textbf{has\_param:} 参数定义 \\
        \bottomrule
    \end{tabular}
\end{table}


\subsubsection{PDCG构建算法}
我们设计了一种基于广度优先搜索（BFS）的单遍扫描算法来构建PDCG，如算法\ref{alg:pdcg_construction_detailed}所示。该算法的核心优势在于，它通过一个处理队列Q和动态更新的函数符号表$F_{defs}$，在一次遍历中即可完成对程序结构的“修剪”与核心行为的“提取”。

算法的执行流程如下：首先，初始化一个\texttt{FILE}类型的根节点，并将AST的顶层语句（如变量声明、函数定义等）作为第0层节点顺序加入队列Q。随后，算法进入主循环，逐层处理队列中的AST节点。在处理过程中，我们采用了一种“中转分发”策略：
\begin{itemize}
    \item \textbf{对于行为节点（如\texttt{CallExpression}和\texttt{FunctionDeclaration}）：} 算法会直接为其创建对应的PDCG节点（\texttt{CALL}或\texttt{FUNCTION\_DEF}），并建立相应的边。特别地，在处理\texttt{FunctionDeclaration}时，会立即将其信息登记到符号表$F_{defs}$中。
    \item \textbf{对于容器节点（如\texttt{VariableDeclaration}和\texttt{ExpressionStatement}）：} 算法并不会为这些纯语法结构创建PDCG节点。相反，它会扮演一个“中转站”的角色，仅将其中包含核心行为的子节点（例如变量的初始值或表达式的主体）重新放入队列的尾部，等待下一轮处理。
\end{itemize}
这种设计确保了PDCG只关注程序的实际行为，而忽略了冗余的语法结构。最后，当算法处理到一个\texttt{CallExpression}时，它会查询符号表$F_{defs}$。由于函数定义在遍历过程中已被提前登记，算法能够可靠地将调用点与包内已知的函数定义点进行关联，从而构建出关键的\texttt{resolves}边，完成跨函数的行为追踪。

% ... a后续是伪代码 \begin{algorithm} ...
% --- 伪代码部分保持不变 ---
\begin{algorithm}[htbp!]
    \caption{PDCG构建算法}
    \label{alg:pdcg_construction_detailed}
    \footnotesize
    \begin{algorithmic}[1]
        \Require JavaScript文件的AST \texttt{ast}
        \Ensure 参数化数据流调用图 PDCG
        
        \State $PDCG \gets$ 初始化空图
        \State $F_{defs} \gets$ 初始化空函数符号表
        \State $Q \gets$ 初始化空队列
        
        \State $fileId \gets PDCG.CreateNode(\text{'FILE'})$
        \For{each $stmt$ in $ast.program.body$}
            \State $Q.push(\{astNode: stmt, parentId: fileId\})$
        \EndFor
        
        \While{$Q$ is not empty}
            \State $item \gets Q.pop()$
            \State $node \gets item.astNode$, $pId \gets item.parentId$
            
            \If{$node.type$ is \texttt{CallExpression}}
                \State $callId \gets HandleCall(node, pId, PDCG, F_{defs})$
                \State $HandleArguments(node.arguments, callId, PDCG, Q)$
            \ElsIf{$node.type$ is \texttt{FunctionDeclaration}}
                \State $funcId \gets PDCG.CreateNode(\text{'FUNCTION\_DEF'}, ...)$
                \State $F_{defs}[node.id.name] \gets funcId$
                \State $PDCG.AddEdge(pId, funcId, \text{'defines'})$
                \For{each $child$ in $node.body.body$}
                    \State $Q.push(\{astNode: child, parentId: funcId\})$
                \EndFor
            \Else
                \For{each $childNode$ in node's relevant children}
                    \State $Q.push(\{astNode: childNode, parentId: pId\})$
                \EndFor
            \EndIf
        \EndWhile
        
        \State \Return $PDCG$
    \end{algorithmic}
\end{algorithm}

\subsubsection{关键设计与示例}
PDCG的设计充分考虑了JavaScript语言的动态和异步特性，以下将通过具体的示例图来展示其对关键行为的建模能力。

\paragraph{链式调用建模} 对于JavaScript中常见的链式调用（如 \texttt{a.b().c()}），我们的算法会递归处理。如图\ref{fig:pdcg_chain_call}所示，它会为\texttt{b()}和\texttt{c()}分别创建\texttt{CALL}节点，并用一条\texttt{chained}类型的边从前一个调用指向后一个调用，从而完整地保留了调用顺序。

% --- 预留位置：链式调用示例图 ---
\begin{figure}[htbp!]
    \centering
    % \includegraphics[width=0.8\columnwidth]{Pictures/pdcg_chain_call_example.png}
    \fbox{\parbox[c][4cm][c]{0.8\columnwidth}{\centering \textit{[预留图片位置: pdcg\_chain\_call\_example.png]} \\ \textit{链式调用对应的PDCG结构}}}
    \caption{链式调用 \texttt{a.b().c()} 对应的PDCG结构}
    \label{fig:pdcg_chain_call}
\end{figure}

\paragraph{参数内容完整提取} PDCG的核心创新在于对参数内容的深度提取。如图\ref{fig:pdcg_argument}所示，对于包含字面量、变量、表达式甚至其他函数调用的复杂参数，PDCG会创建对应的\texttt{ARGUMENT}节点，并记录其内容和类型，这对于判定行为意图至关重要。

% --- 预留位置：参数提取示例图 ---
\begin{figure}[htbp!]
    \centering
    % \includegraphics[width=\columnwidth]{Pictures/pdcg_argument_example.png}
    \fbox{\parbox[c][5cm][c]{\columnwidth}{\centering \textit{[预留图片位置: pdcg\_argument\_example.png]} \\ \textit{复杂参数提取的PDCG结构}}}
    \caption{对包含多种类型内容的复杂参数进行提取的PDCG示例}
    \label{fig:pdcg_argument}
\end{figure}

\paragraph{匿名回调函数识别} 当一个匿名函数（\texttt{FunctionExpression}或\texttt{ArrowFunctionExpression}）被作为参数传递时，我们的算法会创建一个\texttt{ANONYMOUS\_FUNCTION}节点。如图\ref{fig:pdcg_callback}所示，一条\texttt{callback}类型的边会将其与父调用节点连接，清晰地揭示了异步执行模式。

% --- 预留位置：回调函数示例图 ---
\begin{figure}[htbp!]
    \centering
    % \includegraphics[width=0.9\columnwidth]{Pictures/pdcg_callback_example.png}
    \fbox{\parbox[c][5cm][c]{0.9\columnwidth}{\centering \textit{[预留图片位置: pdcg\_callback\_example.png]} \\ \textit{匿名回调函数对应的PDCG结构}}}
    \caption{将匿名函数作为回调参数传递时的PDCG建模}
    \label{fig:pdcg_callback}
\end{figure}

\paragraph{自定义函数解析关联} 当一个调用点调用了包内定义的函数时，PDCG会添加一条\texttt{resolves\_to\_def}的引用边。如图\ref{fig:pdcg_resolution}所示，这条边将\texttt{CALL}节点与对应的\texttt{FUNCTION\_DEF}节点直接关联，极大地便利了跨函数的行为追踪。

% --- 预留位置：函数解析示例图 ---
\begin{figure}[htbp!]
    \centering
    % \includegraphics[width=0.9\columnwidth]{Pictures/pdcg_resolution_example.png}
    \fbox{\parbox[c][5cm][c]{0.9\columnwidth}{\centering \textit{[预留图片位置: pdcg\_resolution\_example.png]} \\ \textit{自定义函数解析的PDCG结构}}}
    \caption{将调用点解析到包内函数定义的PDCG示例}
    \label{fig:pdcg_resolution}
\end{figure}


\subsection{阶段三：基于LLM的恶意行为规则生成}
\label{sec:rule_generation}
仅有高保真的程序图表示是不足的，我们还需要专家知识来指导分析。传统的做法是依赖人类专家手动编写规则，但这种方式扩展性差、成本高。为突破这一局限，我们提出了一种“生成式”的LLM应用范式，将其定位为一个\textbf{知识工程引擎}。

\subsubsection{LLM选型与输入定义}
本研究采用Anthropic公司的\textbf{Claude 3 Sonnet}模型作为知识工程的基础。为确保LLM能够聚焦于核心恶意模式而非复杂的代码逻辑，我们首先从数据集中筛选出约1000个“简单恶意样本”作为其输入。这些样本在经过阶段一的行为虚拟化后，满足以下条件：(1) 包含的JavaScript文件数量不超过2个；(2) 代码逻辑简单，行为直接，非压缩或高度混淆；(3) 人工审查可读性较好。

\subsubsection{迭代式的“扩充-融合”流程}
我们设计了一套迭代式的“扩充-融合”（Augment-Fuse）流程，以半自动化的方式引导LLM构建并精炼知识库。

\begin{enumerate}
    \item \textbf{原子规则生成（扩充阶段）：} 我们将一个简单恶意样本的代码片段输入LLM。通过精心设计的提示（Prompt），引导LLM扮演安全分析师，识别其核心恶意模式，并以我们预定义的、与PDCG匹配的JSON格式输出一条“原子规则”。

    \item \textbf{规则库融合与精炼（融合阶段）：} 在生成了若干新规则后，我们周期性地启动“融合”任务。我们将当前规则库中的所有规则连同少量新规则一同输入LLM，并下达一个更高级的指令：“请分析这些规则，将其中语义重复、模式重叠或可以被更通用模式所包含的规则进行合并与重写。”
\end{enumerate}

在实验过程中我们观察到，当输入样本数量达到约600个时，规则库的增长趋于收敛，后续样本仅对现有规则进行微调或产生少量冗余，不再生成新的核心模式。最终，经过这个流程，我们得到了一个包含87条高质量规则的精简知识库。

\subsubsection{“融合”过程示例}
“融合”是提升规则库质量的关键。例如，在扩充阶段，LLM可能会针对不同的样本生成两条独立的原子规则：
\begin{itemize}
    \item 规则A：检测到URL中包含`oast.site`。
    \item 规则B：检测到URL中包含`webhook.site`。
\end{itemize}
在融合阶段，当这两条规则被同时输入时，LLM能够理解它们都属于“利用带外服务进行数据外泄”这一通用模式，从而将它们泛化并重写为一条更强大的规则，如我们规则库中的\textbf{`DT-008`}。该规则通过一个覆盖更广的正则表达式 `\.(oast\.(site|...)|webhook\.site|...)`，将多个相似的原子模式融合成一个更高层次的、泛化能力更强的知识。这个“扩充-融合”的闭环流程，确保了我们的知识库不仅覆盖面广，而且抽象层次高、不易被简单绕过。

这个流程将LLM强大的代码理解与归纳能力，转化为一个可审查、可扩展、可与下游分析模块深度耦合的知识库。

\subsection{阶段四：协同分析与特征工程}
\label{sec:feature_engineering}
在分别构建了结构化的程序图（PDCG）和语义化的行为规则库之后，本阶段的核心任务是将两者进行协同分析，并从中提取出一套能够全面、深度刻画软件包行为的特征向量。

\subsubsection{语义特征：基于规则匹配的二进制向量}
这类特征旨在回答"软件包是否包含已知的原子恶意行为？"。我们使用规则库对包级PDCG中的每一个节点进行匹配。如果一个节点满足某条规则，我们就在该节点上标记一个"恶意"属性。最终，我们创建一个与规则库等长的二进制特征向量，向量的每一位对应一条规则，如果该规则在图中被至少命中一次，则该位记为1，否则为0。

\subsubsection{结构特征：基于图论的恶意行为画像}
仅仅知道一个包包含了恶意行为是不够的。一个精心设计的恶意软件，其恶意节点在图结构上往往呈现出与正常代码不同的模式。为了量化这些差异，我们计算了一系列图论特征。

\paragraph{基础统计特征}
这类特征描述恶意节点在整个程序图中的基本分布情况：恶意节点数量 $M$，恶意节点比例 $malicious\_ratio$，以及恶意规则类别多样性 $diversity$。
\begin{equation}
    malicious\_ratio = M/|V|
\end{equation}
\begin{equation}
    diversity = \frac{|\{c | \exists v \in V_m, \text{rule}(v) \in \text{class}(c)\}|}{|\text{Classes}|}
\end{equation}

\paragraph{中心性特征}
中心性指标是衡量网络中节点重要性的经典方法\cite{freeman1978centrality}。我们关注度中心性 $C_D(v)$ 和介数中心性 $C_B(v)$。其中，介数中心性的高效计算得益于Brandes提出的算法\cite{brandes2001faster}。我们提取最大恶意度中心性等统计量。高中心性的恶意节点往往是程序的"控制中枢"，是区分"意外触发"与"精心设计"的关键。

\paragraph{PageRank特征}
PageRank算法\cite{page1999pagerank}最初用于网页排名，其核心思想同样适用于评估代码节点在调用图中的递归重要性。
\begin{equation}
PR(v) = \frac{1-d}{|V|} + d \sum_{u \in \text{In}(v)} \frac{PR(u)}{|\text{Out}(u)|}
\end{equation}
其中，$d$是阻尼因子。我们提取的关键特征包括恶意节点PageRank总和与最大值。高PageRank的恶意节点表明它们处于多条调用路径的汇聚点，能够影响程序的多个执行分支。

\paragraph{社区结构特征}
使用Blondel等人提出的Louvain算法\cite{blondel2008fast}对PDCG进行社区划分，并分析恶意节点的社区分布模式。我们计算恶意社区数量、最大社区恶意率以及恶意社区熵等特征。社区结构揭示了恶意行为的"组织模式"，例如，高度集中的恶意节点表明攻击代码具有模块化特征。

\subsection{阶段五：基于机器学习的恶意性判定}
\label{sec:classification}

通过前述阶段，我们将复杂的代码分析问题，成功地转化为一个标准的、基于特征向量的监督式机器学习问题。本阶段的目标是利用上一阶段生成的混合特征向量，训练一个高效且准确的二元分类器，以对输入的NPM软件包做出最终的“良性”或“恶意”判定。

为了找到最优的决策模型，我们系统性地评估了多种主流的机器学习算法（如随机森林、梯度提升树、SVM等）。我们将在一个包含大量已标记样本的数据集上，对这些模型进行训练、验证和测试。通过在交叉验证集上比较它们的F1分数、精确率、召回率和AUC等关键性能指标，我们最终选择表现最优异的模型，作为我们整个协同检测框架的最终分类器。

\section{实验设计}
\label{sec:experiments}

本章详细介绍我们为回答第\ref{sec:introduction}节中提出的三个研究问题（RQs）而设计的实验方案。

\subsection{研究问题重述}
为方便读者，我们在此重述本研究旨在回答的核心问题：RQ1 (有效性), RQ2 (协同性), RQ3 (知识有效性)。

\subsection{数据集构建}
\label{sec:dataset}
我们的实验基于一个包含16,039个真实世界NPM软件包的混合数据集。该数据集的构建受到了Maloss\cite{duan2020towards}和Robust\cite{zheng2024towards}等公开数据集的启发，并在此基础上进行了扩充和交叉验证。数据集由两部分构成：
\begin{itemize}
    \item \textbf{良性样本：} 我们从NPM官方仓库中选取了8,000个软件包作为良性样本。这些样本的选择基于一系列高质量标准，包括高下载量、长存在时间以及广泛的社区流行度，以确保它们是经过长期使用和验证的、可信赖的软件包。
    \item \textbf{恶意样本：} 我们从DataDog维护的公开恶意软件包数据集\cite{datadog2023dataset}中选取了8,039个NPM恶意样本。

\end{itemize}
在实验中，我们采用标准的80/20比例划分训练集和测试集，并使用5折分层交叉验证来确保模型评估的稳定性和可靠性。

\subsection{基线方法}
\label{sec:baselines}
为了全面评估我们方法的有效性（RQ1），我们选择了三种具有代表性的现有恶意软件检测方法作为基线进行对比：
\begin{itemize}
    % --- 修改：删除SOTA的表述 ---
    \item \textbf{Ladisa et al. \cite{ladisa2023feasibility}}: 一种先进的、基于机器学习的方法。它通过提取一组语言无关的特征（如安装脚本的存在、混淆字符串、URL等），训练模型以实现对NPM和PyPI生态的跨语言恶意包检测。该方法代表了基于元数据和词法特征进行检测的技术路线。

    \item \textbf{Amalfi \cite{sejfia2022practical}}: 一种专为NPM生态设计的、实用的自动化检测方法。它同样基于机器学习，但提取了更深层次的特征，如API调用序列等，并使用决策树进行分类。该方法以其轻量级和高效性在学术界受到广泛关注，代表了基于行为序列进行分析的技术路线。

    \item \textbf{OSSGadget \cite{ossgadget}}: 由微软开源的一套实用工具集，其中的`oss-detect-backdoor`工具通过一系列启发式规则和已知恶意代码签名来识别潜在的后门。该工具代表了工业界广泛应用的、基于专家规则的检测方法。
\end{itemize}
这三种基线方法分别代表了三种主流的技术方向：基于元数据/词法的机器学习、基于行为序列的机器学习以及基于专家规则的工业级工具，能够对我们的方法进行全方位的性能评估。

\subsection{评估指标}
\label{sec:metrics}
我们采用分类任务中标准的评估指标来衡量模型的性能。这些指标基于混淆矩阵的四个基本量：真正例（True Positives, TP）、假正例（False Positives, FP）、真反例（True Negatives, TN）和假反例（False Negatives, FN）。

\begin{itemize}
    \item \textbf{准确率 (Accuracy)} 是正确分类的样本占总样本的比例：
    \begin{equation}
    \text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN}
    \end{equation}
    \item \textbf{精确率 (Precision)} 是被预测为正例的样本中，实际为正例的比例，衡量了模型预测的“准确性”：
    \begin{equation}
    \text{Precision} = \frac{TP}{TP + FP}
    \end{equation}
    \item \textbf{召回率 (Recall)} 是所有实际为正例的样本中，被成功预测为正例的比例，衡量了模型对正例的“查全率”：
    \begin{equation}
    \text{Recall} = \frac{TP}{TP + FN}
    \end{equation}
    \item \textbf{F1分数 (F1-Score)} 是精确率和召回率的调和平均数，是我们评估模型综合性能的主要依据：
    \begin{equation}
    \text{F1-Score} = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}
    \end{equation}
\end{itemize}

\section{实验结果与分析}
\label{sec:results}

本章将展示并分析我们的实验结果，旨在逐一回答上一章中提出的三个研究问题。

\subsection{RQ1: 模型性能评估}
\label{sec:rq1}

为回答RQ1，我们首先需要从多个候选模型中为我们的框架选择最佳分类器，然后将其与基线方法进行比较。


\subsubsection{分类器选择}
我们基于第\ref{sec:feature_engineering}节中提取的混合特征，对七种主流机器学习分类器进行了训练和评估。所有模型的实现均基于scikit-learn库\cite{pedregosa2011scikit}。如表\ref{tab:classifier_comparison}所示，\textbf{随机森林（Random Forest）}在F1分数和准确率等关键指标上均表现最佳，达到了98.1\%的F1分数。因此，我们选择随机森林作为我们框架的最终分类器，并将其命名为\textbf{PDCG-LLM-Detect}用于后续的对比实验。

\begin{table}[htbp!]
    \centering
    \caption{不同分类器在我们框架下的性能对比}
    \label{tab:classifier_comparison}
    \footnotesize
    \setlength{\tabcolsep}{3pt}
    \begin{tabular}{lccccc}
        \toprule
        \textbf{分类器} & \textbf{Acc.} & \textbf{Prec.} & \textbf{Rec.} & \textbf{F1} & \textbf{AUC} \\
        \midrule
        \textbf{Random Forest} & \textbf{0.983} & \textbf{0.992} & \textbf{0.971} & \textbf{0.981} & \textbf{0.993} \\
        XGBoost & 0.981 & 0.986 & 0.973 & 0.979 & 0.994 \\
        Gradient Boosting & 0.982 & 0.985 & 0.974 & 0.980 & 0.993 \\
        SVM & 0.981 & 0.992 & 0.966 & 0.978 & 0.992 \\
        Logistic Reg. & 0.975 & 0.979 & 0.966 & 0.972 & 0.989 \\
        Decision Tree & 0.972 & 0.968 & 0.970 & 0.969 & 0.974 \\
        Naive Bayes & 0.948 & 0.959 & 0.924 & 0.941 & 0.966 \\
        \bottomrule
    \end{tabular}
\end{table}

\subsubsection{与基线方法的对比}
我们将我们表现最佳的模型（\textbf{PDCG-LLM-Detect}）与三种基线方法进行比较，结果如表\ref{tab:baseline_comparison}所示。从表中可以清晰地看到，我们的方法在所有关键指标上均优于所有基线方法。与表现第二好的Amalfi相比，我们的方法在F1分数上提升了约1个百分点。这证明了我们提出的协同分析框架的有效性。


\begin{table}[htbp!]
    \centering
    \caption{我们的方法与基线方法的性能对比}
    \label{tab:baseline_comparison}
    \footnotesize
    \begin{tabular}{lcccc}
        \toprule
        \textbf{方法} & \textbf{Acc.} & \textbf{Prec.} & \textbf{Rec.} & \textbf{F1} \\
        \midrule
        \textbf{PDCG-LLM-Detect} & \textbf{0.983} & \textbf{0.992} & \textbf{0.971} & \textbf{0.981} \\
        Amalfi \cite{sejfia2022practical} & 0.970 & 0.973 & 0.970 & 0.971 \\
        Ladisa et al. \cite{ladisa2023feasibility} & 0.976 & 0.929 & 0.845 & 0.885 \\
        OSSGadget \cite{ossgadget} & 0.404 & 0.369 & 0.923 & 0.528 \\
        \bottomrule
    \end{tabular}
\end{table}

\subsubsection{控制变量实验：泛化能力验证}
\label{sec:controlled_experiment}
为了进一步验证我们方法的泛化能力和稳定性（即，其性能并非过拟合于特定的主数据集），我们设计了一个控制变量实验。该实验的核心思想是：\textbf{使用在主数据集上训练好的PDCG-LLM-Detect模型，直接在两个不同来源的、全新的恶意样本集上进行测试}，以评估其泛化表现。

\paragraph{实验设计}
我们使用了两个源自公开研究的外部数据集进行测试：
\begin{itemize}
    \item \textbf{测试集1 (Maloss)}：源自Duan等人\cite{duan2020towards}研究的Maloss数据库中的500个恶意包。
    \item \textbf{测试集2 (Robust)}：源自Zheng等人\cite{zheng2024towards}研究的Robust数据库中的425个恶意包。
\end{itemize}
这两个数据集均未参与我们主模型的训练过程。

\paragraph{实验结果与分析}
如表\ref{tab:generalization_results}所示，\textbf{PDCG-LLM-Detect}在两个全新的数据集上表现出了卓越且稳定的性能。

\begin{table}[htbp!]
    \centering
    \caption{PDCG-LLM-Detect在外部数据集上的泛化性能}
    \label{tab:generalization_results}
    \footnotesize
    \begin{tabular}{lcccc}
        \toprule
        \textbf{测试数据集} & \textbf{Acc.} & \textbf{Prec.} & \textbf{Rec.} & \textbf{F1} \\
        \midrule
        Maloss \cite{duan2020towards} & 0.960 & 0.925 & 0.903 & 0.914 \\
        Robust \cite{zheng2024towards} & 0.969 & 0.931 & 0.921 & 0.926 \\
        \bottomrule
    \end{tabular}
\end{table}

实验结果清晰地表明，即使面对与训练集来源不同的恶意样本，我们的方法依然能够维持超过91\%的F1分数，且在两个数据集上的性能差异仅为1.2个百分点。这强有力地证明了我们提出的协同分析框架和所提取的特征具有良好的泛化能力，能够有效应对多样化的、未知的恶意样本，满足了实际应用对于鲁棒性的严格要求。

% --- 修改：将特征重要性图(fig:feature_importance)移动到RQ2的开头，作为该部分的开篇图 ---
\begin{figure}[htbp!]
    \centering
    \includegraphics[width=\columnwidth]{Pictures/feature_importance_top20.png}
    \caption{Top 20 特征重要性排名。蓝色条形表示图结构特征，红色条形表示规则特征。可以清楚地看到，前三名特征均为图特征，验证了PDCG结构分析的重要价值。}
    \label{fig:feature_importance}
\end{figure}

\subsection{RQ2: 协同机制贡献度分析}
\label{sec:rq2}

为回答RQ2，我们进行了一系列实验来探究规则特征和图特征的各自贡献以及它们之间的协同效应。

\subsubsection{特征重要性分析}
我们首先分析了随机森林模型给出的特征重要性排名。如图\ref{fig:feature_importance}所示，在Top 20最重要的特征中，图特征和规则特征均有上榜，且排名靠前。

值得注意的是，最重要的三个特征——\texttt{malicious\_ratio}（恶意节点比例）、\texttt{max\_community\_maliciousness\_ratio}（最大社区恶意率）和\texttt{sum\_malicious\_pagerank}（恶意节点PageRank总和）——均为描述恶意行为全局画像的图特征。这一现象深刻地揭示了，单个原子性的恶意行为固然是判定的基础，但这些行为在代码结构中的聚集程度和中心地位，是区分复杂恶意软件与良性包（可能包含某些高危函数用于正常功能）的更关键指标。紧随其后的是\texttt{rule\_PE-001}，一个描述高危代码执行的强语义规则。这完美印证了我们的核心假设：模型不仅依赖于具体的恶意行为，更依赖于这些行为在代码中的组织方式和上下文。

\subsubsection{消融实验}
为了更直接地验证协同效应，我们进行了消融实验，分别使用“仅规则特征”、“仅图特征”和“全部特征”来训练模型。结果如表\ref{tab:ablation_study}所示。

\begin{table}[htbp!]
    \centering
    \caption{特征消融实验结果 (Random Forest)}
    \label{tab:ablation_study}
    \footnotesize
    \begin{tabular}{lcccc}
        \toprule
        \textbf{特征集} & \textbf{Acc.} & \textbf{Prec.} & \textbf{Rec.} & \textbf{F1} \\
        \midrule
        \textbf{All Features} & \textbf{0.9832} & \textbf{0.9916} & \textbf{0.9711} & \textbf{0.9813} \\
        Rules Only & 0.9794 & 0.9853 & 0.9691 & 0.9771 \\
        Graph Only & 0.9788 & 0.9860 & 0.9670 & 0.9764 \\
        \bottomrule
    \end{tabular}
\end{table}

实验结果清晰地表明：(1) “仅规则特征”和“仅图特征”都能取得相当不错的性能，证明了这两类特征都具有很强的独立判别能力。(2) 使用“全部特征”的模型性能优于任何单一特征集的模型。这一结果强有力地证明了我们的核心假设，即语义特征和结构特征之间存在协同效应。

% --- 修改：将t-SNE图(fig:tsne_visualization)移动到其分析段落之后，作为该部分的收尾图 ---
\subsubsection{特征空间可视化分析}
为了更直观地理解不同特征类型的区分能力和协同效应，我们采用t-SNE\cite{maaten2008visualizing}降维技术对高维特征空间进行可视化分析。

图\ref{fig:tsne_visualization}展示了三种特征组合下的t-SNE可视化结果。从图中可以清楚地观察到：

\begin{enumerate}
    \item \textbf{单一特征集的有效性}：无论是“仅规则特征”（图\ref{fig:tsne_rules}）还是“仅图特征”（图\ref{fig:tsne_graph}），恶意包（红色）和良性包（蓝色）都形成了相对清晰的聚类，证明了这两类特征都具备强大的独立判别能力。
    
    \item \textbf{融合特征的协同效应}：当使用“全部特征”时（图\ref{fig:tsne_all}），可以观察到两个类别的聚类变得更加紧凑，类间的分离边界也更为清晰和宽阔。这表明，尽管单一特征集已足够有效，但两者的结合能够让分类器学习到一个更鲁棒的决策边界，从而在特征空间中实现更优质的类别分离。
\end{enumerate}

这一可视化分析从另一个角度印证了我们在消融实验中得出的结论：规则特征和图特征各自都具有强大的判别能力，但它们的结合能够产生1+1>2的协同效应，从而实现更精准的恶意包识别。

\begin{figure*}[htbp!]
    \centering
    \begin{subfigure}{0.32\textwidth}
        \centering
        \includegraphics[width=\textwidth]{Pictures/4_tsne_clustering_rules.png}
        \caption{仅规则特征}
        \label{fig:tsne_rules}
    \end{subfigure}
    \hfill
    \begin{subfigure}{0.32\textwidth}
        \centering
        \includegraphics[width=\textwidth]{Pictures/4_tsne_clustering_graph.png}
        \caption{仅图特征}
        \label{fig:tsne_graph}
    \end{subfigure}
    \hfill
    \begin{subfigure}{0.32\textwidth}
        \centering
        \includegraphics[width=\textwidth]{Pictures/4_tsne_clustering_all.png}
        \caption{全部特征}
        \label{fig:tsne_all}
    \end{subfigure}
    \caption{不同特征组合的t-SNE降维可视化。红色点代表恶意包，蓝色点代表良性包。}
    \label{fig:tsne_visualization}
\end{figure*}

\subsection{RQ3: LLM作为知识引擎的有效性评估}
\label{sec:rq3}


本节旨在直接回答我们研究的核心驱动问题（RQ3）：\textbf{LLM能否扮演一个高效的“知识工程师”，从有限的简单样本中，提炼出能够指导复杂场景检测的、高质量且具备泛化能力的恶意行为知识库？}

\subsubsection{知识的来源与提炼}
我们的实验设计直接模拟了这一研究思路。我们向LLM输入了约1000个代码结构简单的“原子恶意样本”，通过“扩充-融合”的迭代式提示策略，引导LLM完成了两项关键任务：
\begin{enumerate}
    \item \textbf{知识发现：} 从具体案例中识别并归纳出原子性的恶意行为模式。
    \item \textbf{知识抽象：} 将相似的、重复的模式进行合并与泛化，形成更高级、更通用的规则。
\end{enumerate}
经过这个过程，LLM最终为我们提炼出一个仅包含87条规则的精简知识库。这个过程本身就是对LLM知识工程能力的证明。

\subsubsection{知识的有效性：从简单样本到复杂场景的泛化能力}
衡量这个知识库价值的关键，在于它能否从“已知的简单案件”中学习，并成功应用于“未知的复杂案件”。我们的实验结果强有力地证明了这一点。

\paragraph{证据一：极高的恶意行为覆盖率}
我们首先分析了由LLM生成的87条规则，在包含7274个真实恶意包的测试集上的覆盖效果。结果是决定性的：\textbf{有多达7172个恶意包（占比98.60\%）被至少一条规则命中。}

这一数据无可辩驳地证明了，LLM作为一个知识引擎，成功地从有限的样本中学习并归纳出了一个泛化能力极强的知识库。更重要的是，如图\ref{fig:rule_coverage}所示的分布情况揭示，绝大多数被命中的恶意包并非仅被单一规则识别，而是同时命中了多条规则。这种多重命中现象表明，我们的规则库能够从不同维度对同一个恶意软件包进行协同画像（例如，一个包可能同时触发“信息收集”、“代码执行”和“数据外泄”三类规则），这不仅避免了依赖单一脆弱规则进行判断的风险，也极大地增强了检测结果的置信度。

% --- 修改：将规则覆盖率图(fig:rule_coverage)移动到其分析段落之后，确保文图对应 ---
\begin{figure}[htbp!]
    \centering
    \includegraphics[width=\columnwidth]{Pictures/rule_coverage_distribution.png}
    \caption{恶意包的规则命中数分布图 (Y轴为对数尺度)。横轴表示一个恶意包命中了多少条规则，纵轴表示对应数量的恶意包个数。}
    \label{fig:rule_coverage}
\end{figure}

\paragraph{证据二：全面的知识类别覆盖}
我们对这87条规则进行了主题归纳，如表\ref{tab:rule_categories}所示。分析发现，规则库的知识覆盖面广且重点突出。\textbf{负载执行（PE）} 类规则数量最多，占比高达48.3\%，这与恶意软件以代码执行为核心的本质高度吻合。其次是 \textbf{数据传输（DT）} 和 \textbf{信息收集（IG）}，分别占比23.0\%和16.1\%，共同构成了恶意行为的“侦察-外泄”主链条。

这些规则不仅覆盖了已知的攻击手法，我们还发现LLM具备了一定的洞察力，能够归纳出传统规则库中较少涉及的新型攻击模式。例如，规则 \textbf{`DT-008`} 精准地捕捉了利用各类带外应用安全测试（Out-of-Band Application Security Testing, OAST）平台和Webhook服务进行数据外泄的通用模式。这种攻击手法在近年的供应链攻击中愈发常见，而LLM能够自动提炼出此类前瞻性的攻击向量，充分证明了其作为知识引擎的潜力与价值。

\begin{table}[htbp!]
    \centering
    \caption{LLM生成的87条规则类别分布统计}
    \label{tab:rule_categories}
    \footnotesize
    \begin{tabular}{llcc}
        \toprule
        \textbf{类别缩写} & \textbf{类别全称} & \textbf{数量} & \textbf{占比} \\
        \midrule
        PE & Payload Execution (负载执行) & 42 & 48.3\% \\
        DT & Data Transmission (数据传输) & 20 & 23.0\% \\
        IG & Information Gathering (信息收集) & 14 & 16.1\% \\
        DE & Data Encoding (数据编码) & 7 & 8.0\% \\
        SP & Special Patterns (特殊模式) & 4 & 4.6\% \\
        \midrule
        \textbf{总计} & - & \textbf{87} & \textbf{100\%} \\
        \bottomrule
    \end{tabular}
\end{table}

\paragraph{证据三：稳定的跨数据集表现}
在控制变量实验中（见第\ref{sec:controlled_experiment}节），仅规则特征在两个完全不同的恶意样本集（Maloss, Robust）上表现出稳定且优异的性能。

\subsubsection{结论：LLM作为知识引擎的价值}
综上所述，本节的实验结果构成了最坚实的证据链，证明了我们提出的LLM应用范式的核心价值。LLM成功地扮演了一个高效的知识工程师角色，它从有限的、简单的输入中，提炼并构建了一个精简、高效、覆盖全面且泛化能力极强的恶意行为知识库。正是这个高质量的知识库，为我们的框架提供了关键的专家知识，指导其在复杂的PDCG中精准地搜寻恶意行为证据，最终实现了卓越的检测性能。

\section{讨论}
\label{sec:discussion}

我们的研究结果不仅展示了一个高性能的检测器，更重要的是，它为理解和应对NPM生态系统的安全威胁提供了新的视角。

本研究的核心意义在于为维护NPM社区的整体安全提供了一种兼具深度和广度的解决方案。对于广大的开发者而言，他们常常在不知情的情况下引入了恶意的上游依赖，导致自己的软件成为攻击链条的一环。我们的方法能够在软件包进入开发流程前进行深度审计，帮助开发者规避此类风险，降低其成为“加害者”的可能。对于最终用户而言，他们是软件供应链攻击的最终受害者。一个更安全的NPM生态意味着更少的个人数据泄露、财产损失和系统安全风险。我们的工作通过提升恶意包的检测能力，直接为保护数以亿计的终端用户贡献了一份力量。

我们提出的“语义与结构协同”框架，其本质是一个“双重验证”模型。LLM生成的规则库如同一个经验丰富的安全专家，负责识别那些具有明确恶意意图的行为；而PDCG的图特征则像一个结构工程师，负责审查代码的组织是否“行为反常”。这种结合使得我们的方法既能捕捉已知的攻击模式，也能对未知的、结构异常的潜在威胁保持警惕，这对于应对快速演变的攻击手法至关重要。

当然，我们的工作也存在一些局限性。首先，作为一个静态分析框架，它天然地难以应对那些完全在运行时通过动态代码执行（如`eval`一个从远端获取的字符串）来实施的攻击。其次，我们的规则生成过程虽然高效，但其质量仍与LLM的能力和提示工程的水平强相关，尚未达到完全自动化的理想状态。最后，我们的框架目前专注于NPM生态，将其直接迁移到其他语言生态（如PyPI、Maven）需要针对性地重新设计PDCG解析器。

这些局限性也为未来的研究指明了方向。将我们的静态分析框架与沙箱等动态分析技术相结合，构建一个动静结合的检测系统，将是弥补当前短板的有效途径。此外，探索直接在PDCG上应用图神经网络（GNN）进行端到端的学习，可能会发现人类和LLM都难以察觉的、更深层次的恶意结构模式。最后，研究针对我们检测框架的对抗性攻击，并以此为基础持续增强模型的鲁棒性，也是一个极具价值的研究方向。

\section{结论}
\label{sec:conclusion}

本文针对日益严峻的软件供应链攻击，提出了一种协同参数化数据流调用图（PDCG）与大语言模型（LLM）的NPM恶意包检测框架。我们通过PDCG对程序的结构和数据流进行深度建模，并创新性地利用LLM以“生成式”范式构建了一个可解释、可扩展的恶意行为规则库。

实验结果表明，我们的方法在一个包含超过16,000个真实NPM包的数据集上取得了98.1\%的F1分数，其性能优于现有基线方法。我们进一步通过消融实验和特征重要性分析，验证了PDCG的结构特征与LLM的语义规则之间存在协同效应，并揭示了其背后“双重防御”的工作机制。

本研究的核心贡献在于，不仅提供了一个高性能的恶意软件包检测器，更重要的是提出了一种“白盒化”地利用LLM赋能程序安全分析的新思路。通过将LLM定位为知识工程引擎，我们成功地将其强大的代码理解能力转化为可审计、可与下游工具集成的结构化知识，为应对未来更高级、更隐蔽的软件供应链威胁提供了坚实的理论基础和强大的技术储备。



\begin{thebibliography}{00}

% --- 按文中出现顺序排序 ---

% 1. 引言部分
\bibitem{sonatype} Sonatype. (2024). 10th Annual State of the Software Supply Chain Report.
\bibitem{he2020software} He, X., Zhang, Y., \& Liu, Q. (2020). A Survey on Software Supply Chain Security. \textit{Journal of Information Security}, 5(1), 57-73.
\bibitem{ji2022opensource} Ji, S., Wang, Q., Chen, A., et al. (2022). A Survey on Open Source Software Supply Chain Security Research. \textit{Journal of Software}, 34(3), 1330-1364.
\bibitem{martinez2021software} Martínez, J., \& Durán, J. M. (2021). Software supply chain attacks, a threat to global cybersecurity: SolarWinds’ case study. \textit{International Journal of Safety and Security Engineering}, 11(5), 537-545.
\bibitem{apache2022log4j} The Apache Software Foundation. (2022). Apache Log4j Security Vulnerabilities. Retrieved from https://logging.apache.org/log4j/2.x/security.html
\bibitem{zimmermann2019small} Zimmermann, M., et al. (2019). Small world with high risks: A study of security threats in the npm ecosystem. In \textit{28th USENIX Security Symposium}.
\bibitem{liu2018software} Liu, J., Su, P., Yang, M., et al. (2018). A Survey on Software and Network Security Research. \textit{Journal of Software}, 29(1), 42-68.
\bibitem{zahan2022weak} Zahan, N., et al. (2022). What are weak links in the npm supply chain?. In \textit{Proceedings of the 44th International Conference on Software Engineering: Software Engineering in Practice}.
\bibitem{liu2022demystifying} Liu, C., et al. (2022). Demystifying the vulnerability propagation and its evolution via dependency trees in the npm ecosystem. In \textit{Proceedings of the 44th International Conference on Software Engineering}.
\bibitem{ladisa2023sok} Ladisa, P., et al. (2023). Sok: Taxonomy of attacks on open-source software supply chains. In \textit{2023 IEEE Symposium on Security and Privacy (SP)}.
\bibitem{su2024learning} Su, X., Zheng, W., Jiang, Y., et al. (2024). Research and Progress on Learning-Based Source Code Vulnerability Detection. \textit{Chinese Journal of Computers}, 47(2), 337-361.

% 2. 相关工作部分
\bibitem{halder2024malicious} Halder, S., et al. (2024). Malicious package detection using metadata information. In \textit{Proceedings of the ACM Web Conference 2024}.
\bibitem{samaana2025machine} Samaana, H., et al. (2025). A Machine Learning-Based Approach For Detecting Malicious PyPI Packages. In \textit{Proceedings of the 40th ACM/SIGAPP Symposium on Applied Computing}.
\bibitem{ladisa2023feasibility} Ladisa, P., et al. (2023). On the feasibility of cross-language detection of malicious packages in npm and pypi. In \textit{Proceedings of the 39th annual computer security applications conference}.
\bibitem{sun20241+} Sun, X., et al. (2024). 1+ 1> 2: Integrating deep code behaviors with metadata features for malicious PyPI package detection. In \textit{Proceedings of the 39th IEEE/ACM international conference on automated software engineering}.
\bibitem{sejfia2022practical} Sejfia, A., \& Schäfer, M. (2022). Practical automated detection of malicious npm packages. In \textit{Proceedings of the 44th international conference on software engineering}.
\bibitem{huang2024donapi} Huang, C., et al. (2024). DONAPI: Malicious NPM Packages Detector using Behavior Sequence Knowledge Mapping. In \textit{33rd USENIX Security Symposium (USENIX Security 24)}.
\bibitem{zhang2023malicious} Zhang, J., et al. (2023). Malicious package detection in npm and pypi using a single model of malicious behavior sequence. \textit{arXiv preprint arXiv:2309.02637}.
\bibitem{yu2024maltracker} Yu, Z., et al. (2024). Maltracker: A fine-grained npm malware tracker copiloted by llm-enhanced dataset. In \textit{Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis}.
\bibitem{huang2024spiderscan} Huang, Y., et al. (2024). SpiderScan: Practical detection of malicious NPM packages based on graph-based behavior modeling and matching. In \textit{Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering}.
\bibitem{liang2023needle} Liang, W., et al. (2023). A needle is an outlier in a haystack: hunting malicious pypi packages with code clustering. In \textit{2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE)}.
\bibitem{ohm2022towards} Ohm, M., et al. (2022). Towards Detection of Malicious Software Packages Through Code Reuse by Malevolent Actors. \textit{Gesellschaft für Informatik, Bonn}.
\bibitem{zheng2024towards} Zheng, X., et al. (2024). Towards robust detection of open source software supply chain poisoning attacks in industry environments. In \textit{Proceedings of the 39th IEEE/ACM international conference on automated software engineering}.
\bibitem{iqbal2025pypiguard} Iqbal, T., et al. (2025). PypiGuard: A novel meta-learning approach for enhanced malicious package detection in PyPI through static-dynamic feature fusion. \textit{Journal of Information Security and Applications}, 90, 104032.
\bibitem{zahan2024leveraging} Zahan, N., et al. (2024). Leveraging large language models to detect npm malicious packages. \textit{arXiv preprint arXiv:2403.12196}.
\bibitem{zeshan2024they} Zeshan, M. U., et al. Are They a Silver Bullet? On the Ability of Llms To Detect Malicious Code in Pypi Packages. \textit{Preprint submitted to Information and Software Technology}.
\bibitem{xue2024poster} Xue, D., et al. (2024). Poster: An Exploration of Large Language Models in Malicious Source Code Detection. In \textit{Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security}.
\bibitem{wang2025malpacdetector} Wang, J., et al. (2025). MalPacDetector: An LLM-based Malicious NPM Package Detector. \textit{IEEE Transactions on Information Forensics and Security}.
\bibitem{zhang2025automatically} Zhang, X., et al. (2025). Automatically generating rules of malicious software packages via large language model. In \textit{2025 55th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN)}.
\bibitem{yamaguchi2014modeling} Yamaguchi, F., et al. (2014). Modeling and discovering vulnerabilities with code property graphs. In \textit{2014 IEEE Symposium on Security and Privacy (SP)}.

% 3. 方法论部分
\bibitem{freeman1978centrality} Freeman, L. C. (1978). Centrality in social networks: Conceptual clarification. \textit{Social networks}, 1(3), 215-239.
\bibitem{brandes2001faster} Brandes, U. (2001). A faster algorithm for betweenness centrality. \textit{Journal of mathematical sociology}, 25(2), 163-177.
\bibitem{page1999pagerank} Page, L., Brin, S., Motwani, R., \& Winograd, T. (1999). The PageRank citation ranking: Bringing order to the web. \textit{Stanford InfoLab}.
\bibitem{blondel2008fast} Blondel, V. D., Guillaume, J. L., Lambiotte, R., \& Lefebvre, E. (2008). Fast unfolding of communities in large networks. \textit{Journal of statistical mechanics: theory and experiment}, 2008(10), P10008.

% 4. 实验设计部分
\bibitem{duan2020towards} Duan, R., et al. (2020). Towards measuring supply chain attacks on package managers for interpreted languages. \textit{arXiv preprint arXiv:2002.01139}.
\bibitem{ossgadget} Bertus, M. (2020). OSSGadget: A collection of tools for analyzing open source packages. Microsoft. Available: https://github.com/microsoft/OSSGadget.
\bibitem{datadog2023dataset} Datadog Security Labs. (2023). Open-Source Dataset of Malicious Software Packages. Available: https://github.com/DataDog/malicious-software-packages-dataset.

% 5. 实验结果部分
\bibitem{pedregosa2011scikit} Pedregosa, F., et al. (2011). Scikit-learn: Machine learning in Python. \textit{the Journal of machine Learning research}, 12, 2825-2830.
\bibitem{maaten2008visualizing} Van der Maaten, L., \& Hinton, G. (2008). Visualizing data using t-SNE. \textit{Journal of machine learning research}, 9(11), 2579-2605.

\end{thebibliography}

\end{document}